package com.javasoft.service.XGX.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.javasoft.dao.XGX.QuestionDao;
import com.javasoft.entity.XGX.Question;
import com.javasoft.service.XGX._interface.QuestionService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

@Service
@Slf4j
public class QuestionImpl extends ServiceImpl<QuestionDao, Question> implements QuestionService {


    /**
     * 前端查询页面需要接收查询页码,页数,id或者题目描述des,优先根据id进行查询,用于管理者查看题库
     * @param currentPage
     * @param pageSize
     * @param des
     * @param id
     * @return
     */


    @Override
// 分页查询
    public Page<Question> searchPage(Long id,
                                     Integer currentPage,
                                     Integer pageSize,
                                     String des,
                                     String knoPoint,
                                     String type,
                                     String subject,
                                     Integer difRank) {
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();

        // 根据id精确查询
        if (id!= null) {
            wrapper.eq(Question::getId, id);
            return super.page(new Page<>(currentPage, pageSize), wrapper);
        }
        // 根据题目描述des模糊查询
        else if (!"".equals(des) && des!= null) {
            wrapper.like(Question::getDes, des);
            return super.page(new Page<>(currentPage, pageSize), wrapper);
        }

        // 根据科目查询
        else if (!"".equals(subject) && subject!= null) {
            if (!"".equals(knoPoint) && knoPoint!= null) {
                if (difRank!= null && difRank!= -1) {
                    wrapper.and(w -> {
                        w.like(Question::getSubject, subject);
                        w.eq(Question::getDifrank, difRank);
                        w.like(Question::getKnopoint, knoPoint);
                    });
                    return super.page(new Page<>(currentPage, pageSize), wrapper);
                }
                wrapper.and(w -> {
                    w.like(Question::getSubject, subject);
                    w.like(Question::getKnopoint, knoPoint);
                });
                return super.page(new Page<>(currentPage, pageSize), wrapper);
            }
            if (!"".equals(type) && type!= null) {
                if (difRank!= null && difRank!= -1) {
                    wrapper.and(w -> {
                        w.like(Question::getSubject, subject);
                        w.eq(Question::getDifrank, difRank);
                        w.like(Question::getType, type);
                    });
                    return super.page(new Page<>(currentPage, pageSize), wrapper);
                }
                wrapper.and(w -> {
                    w.like(Question::getSubject, subject);
                    w.like(Question::getType, type);
                });
                return super.page(new Page<>(currentPage, pageSize), wrapper);
            }
            if (difRank!= null && difRank!= -1) {
                wrapper.and(w -> {
                    w.like(Question::getSubject, subject);
                    w.eq(Question::getDifrank, difRank);
                });
                return super.page(new Page<>(currentPage, pageSize), wrapper);
            }
            wrapper.like(Question::getSubject, subject);
            return super.page(new Page<>(currentPage, pageSize), wrapper);

        }
        else if (!"".equals(type) && type!= null) {
            wrapper.like(Question::getType, type);
            return super.page(new Page<>(currentPage, pageSize), wrapper);
        }

        // 什么都没有就返回一个空页
        else {
            return new Page<>(currentPage, pageSize);
        }
    }


    /**
     * 生成训练题的查询
     * @param subject
     * @param knoPoint
     * @param type
     * @param difRank
     * @return
     */

    @Override
    public List<Question> getQuestions(String subject,
                                       String knoPoint,
                                       String type,
                                       Integer difRank) {
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();

        // 根据科目（subject）进行查询相关逻辑判断
        if (!"".equals(subject) && subject!= null) {
            // 当科目（subject）、知识点（knoPoint）都不为空时，根据科目、知识点进行模糊查询
            if (!"".equals(knoPoint) && knoPoint!= null) {
                // 当科目（subject）、知识点（knoPoint）、难度等级（difRank）都不为空时，
                // 根据科目、知识点进行模糊查询，并且筛选出难度等级等于给定值的记录
                if (difRank!= null && difRank!= -1) {
                    wrapper.and(w -> {
                        w.like(Question::getSubject, subject);
                        w.eq(Question::getDifrank, difRank);
                        w.like(Question::getKnopoint, knoPoint);
                    });
                    return baseMapper.selectList(wrapper);
                }

                // 当科目（subject）、知识点（knoPoint）不为空，仅根据科目、知识点进行模糊查询
                wrapper.and(w -> {
                    w.like(Question::getSubject, subject);
                    w.like(Question::getKnopoint, knoPoint);
                });
                return baseMapper.selectList(wrapper);
            }

            // 当科目（subject）、题目类型（type）都不为空时，根据科目、题目类型进行模糊查询
            if (!"".equals(type) && type!= null) {
                // 当科目（subject）、题目类型（type）、难度等级（difRank）都不为空时，
                // 根据科目、题目类型进行模糊查询，并且筛选出难度等级等于给定值的记录
                if (difRank!= null && difRank!= -1) {
                    wrapper.and(w -> {
                        w.like(Question::getSubject, subject);
                        w.eq(Question::getDifrank, difRank);
                        w.like(Question::getType, type);
                    });
                    return baseMapper.selectList(wrapper);
                }

                // 当科目（subject）、题目类型（type）不为空，仅根据科目、题目类型进行模糊查询
                wrapper.and(w -> {
                    w.like(Question::getSubject, subject);
                    w.like(Question::getType, type);
                });
                return baseMapper.selectList(wrapper);
            }

            // 当科目（subject）不为空，难度等级（difRank）不为空时，
            // 根据科目进行模糊查询，并筛选出难度等级等于给定值的记录
            if (difRank!= null && difRank!= -1) {
                wrapper.and(w -> {
                    w.like(Question::getSubject, subject);
                    w.eq(Question::getDifrank, difRank);
                });
                return baseMapper.selectList(wrapper);
            }

            // 仅当科目（subject）不为空时，根据科目进行模糊查询
            wrapper.like(Question::getSubject, subject);
            return baseMapper.selectList(wrapper);

        }

        // 根据题目类型（type）进行查询，当题目类型（type）不为空时，根据题目类型进行模糊查询
        else if (!"".equals(type) && type!= null) {
            wrapper.like(Question::getType, type);
            return baseMapper.selectList(wrapper);
        }

        // 如果传入的科目（subject）、知识点（knoPoint）、题目类型（type）都为空，即没有任何查询条件时，返回一个空列表
        else {
            return Collections.emptyList();
        }
    }

    /**
     * 输入Questions类对象,根据数据表中是否有该id,决定是保存还是更新
     * @param questions
     * @return
     */
    @Override
    public Long saveOrupdate(Question questions) {
        if (questions.getId()!= null) {
            // 先尝试查询数据库中是否已存在该id对应的记录
            Question existingQuestion = getById(questions.getId());
            if (existingQuestion == null) {
                // 如果不存在，则执行插入操作，使用传入的id新建一条数据
                save(questions);
            } else {
                // 如果存在，则执行更新操作

                updateById(questions);
            }
            return questions.getId();
        } else {
            // id为空时，直接执行保存操作，数据库会自动为题目生成id
            save(questions);
            return questions.getId();
        }
    }
    /**
     * 输入多个ids进行删除
     * @param ids
     * @return
     */
    @Override
    public List<Integer> deleteBatchIds(List<Integer> ids) {
        removeByIds(ids);
        return ids;
    }

    @Override
    //返回所有数据
    public Page<Question> getAllData(Integer currentPage, Integer pageSize) {
        // 创建Page对象，传入当前页码和每页显示数量
        Page<Question> page = new Page<>(currentPage, pageSize);
        // 调用MyBatis-Plus的selectPage方法进行分页查询，第二个参数为查询条件，这里查询全部数据，传入null
        baseMapper.selectPage(page, null);
        return page;
    }

    /**
     * 根据问题类型获取问题列表。
     *
     * @param type 问题类型
     * @return 符合类型的问题列表
     */

    @Override
    public List<Long> getQuestionsByTypeSubject(String type, String subject,Integer difRank) {
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(Question::getId) // 假设Question实体中有id字段
                .eq(Question::getType, type) // 根据问题类型筛选
                .eq(Question::getSubject, subject)// 新增：根据科目筛选，假设Question实体中有一个subject字段
                .eq(Question::getDifrank,difRank);
        return baseMapper.selectList(wrapper)
                .stream()
                .map(Question::getId) // 映射每个Question实体到其id
                .distinct() // 确保每个题目ID只出现一次，尽管这里可能不需要，因为数据库查询应该已经去重
                .collect(Collectors.toList());
    }

    /**
     * 只根据id查询
     * @param ids
     * @return
     */
    @Override
    public List<Question> getOnlyById(List<Long> ids) {
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Question::getId, ids);
        return baseMapper.selectList(wrapper);
    }

}